/**
 * @file cfg_utils.c
 * @brief 通用配置文件解析工具实现
 * @details 本文件实现了通用的配置文件解析功能，支持cfg格式的配置文件。
 *          采用key=value格式，支持注释行（以#开头）。
 * 
 * @author zyb
 * @date 2025-09-25
 * @version 1.0
 * 
 * @note 本模块是通用的配置文件解析工具
 * @warning 配置文件格式必须严格遵循key=value格式
 */

#include "cfg_utils.h"
#include "logger.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
// 定义模块名称
#define LOG_MODULE_NAME "CFG_UTILS"

// 全局错误信息
static char g_error_message[512] = {0};

/* ==================== 函数实现 ==================== */

/**
 * @brief 初始化cfg工具
 * @details 初始化cfg工具模块
 * 
 * @return 初始化结果
 */
int cfg_utils_init(void) {
    LOG_DEBUG(LOG_MODULE_NAME, "初始化cfg工具模块");
    
    // 清空错误信息
    memset(g_error_message, 0, sizeof(g_error_message));
    
    LOG_INFO(LOG_MODULE_NAME, "cfg工具模块初始化完成");
    return 0;
}

/**
 * @brief 销毁cfg工具
 * @details 清理cfg工具资源
 */
void cfg_utils_destroy(void) {
    LOG_DEBUG(LOG_MODULE_NAME, "销毁cfg工具模块");
    
    // 清空错误信息
    memset(g_error_message, 0, sizeof(g_error_message));
    
    LOG_INFO(LOG_MODULE_NAME, "cfg工具模块销毁完成");
}

/**
 * @brief 加载cfg配置文件
 * @details 从cfg文件加载配置，使用回调函数处理每个配置项
 * 
 * @param cfg_file cfg文件路径
 * @param callback 配置项处理回调函数
 * @param user_data 用户数据指针
 * @return 加载结果
 */
cfg_result_t cfg_utils_load_file(const char *cfg_file, cfg_item_callback_t callback, void *user_data) {
    LOG_DEBUG(LOG_MODULE_NAME, "加载cfg配置文件: %s", cfg_file);
    
    if (!cfg_file) {
        LOG_ERROR(LOG_MODULE_NAME, "配置文件路径为空");
        snprintf(g_error_message, sizeof(g_error_message), "配置文件路径为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    if (!callback) {
        LOG_ERROR(LOG_MODULE_NAME, "回调函数为空");
        snprintf(g_error_message, sizeof(g_error_message), "回调函数为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    FILE *file = fopen(cfg_file, "r");
    if (!file) {
        LOG_ERROR(LOG_MODULE_NAME, "无法打开配置文件: %s, 错误: %s", cfg_file, strerror(errno));
        snprintf(g_error_message, sizeof(g_error_message), "无法打开配置文件: %s, 错误: %s", cfg_file, strerror(errno));
        return CFG_ERROR_FILE_NOT_FOUND;
    }
    
    char line[512];
    int line_number = 0;
    int parsed_count = 0;
    
    while (fgets(line, sizeof(line), file)) {
        line_number++;
        
        // 去除换行符
        line[strcspn(line, "\r\n")] = '\0';
        
        // 跳过空行和注释行
        if (strlen(line) == 0 || cfg_utils_is_comment_line(line)) {
            continue;
        }
        
        // 解析配置行
        char key[128], value[256];
        cfg_result_t result = cfg_utils_parse_line(line, key, value);
        if (result != CFG_SUCCESS) {
            LOG_ERROR(LOG_MODULE_NAME, "解析第%d行失败: %s", line_number, line);
            snprintf(g_error_message, sizeof(g_error_message), "解析第%d行失败: %.*s", line_number, (int)(sizeof(g_error_message) - 50), line);
            fclose(file);
            return result;
        }
        
        // 调用回调函数处理配置项
        result = callback(key, value, user_data);
        if (result != CFG_SUCCESS) {
            LOG_ERROR(LOG_MODULE_NAME, "处理配置项失败: %s=%s", key, value);
            snprintf(g_error_message, sizeof(g_error_message), "处理配置项失败: %s=%s", key, value);
            fclose(file);
            return result;
        }
        
        parsed_count++;
    }
    
    fclose(file);
    
    LOG_INFO(LOG_MODULE_NAME, "cfg配置文件加载成功: %s, 解析了%d个配置项", cfg_file, parsed_count);
    return CFG_SUCCESS;
}

/**
 * @brief 保存cfg配置文件
 * @details 将配置项保存为cfg格式文件
 * 
 * @param cfg_file cfg文件路径
 * @param items 配置项数组
 * @param item_count 配置项数量
 * @param header_comment 文件头注释（可为NULL）
 * @return 保存结果
 */
cfg_result_t cfg_utils_save_file(const char *cfg_file, const cfg_item_t *items, size_t item_count, const char *header_comment) {
    LOG_DEBUG(LOG_MODULE_NAME, "保存cfg配置文件: %s, 配置项数量: %zu", cfg_file, item_count);
    
    if (!cfg_file) {
        LOG_ERROR(LOG_MODULE_NAME, "配置文件路径为空");
        snprintf(g_error_message, sizeof(g_error_message), "配置文件路径为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    if (!items) {
        LOG_ERROR(LOG_MODULE_NAME, "配置项数组为空");
        snprintf(g_error_message, sizeof(g_error_message), "配置项数组为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    FILE *file = fopen(cfg_file, "w");
    if (!file) {
        LOG_ERROR(LOG_MODULE_NAME, "无法创建配置文件: %s, 错误: %s", cfg_file, strerror(errno));
        snprintf(g_error_message, sizeof(g_error_message), "无法创建配置文件: %s, 错误: %s", cfg_file, strerror(errno));
        return CFG_ERROR_SAVE_FAILED;
    }
    
    // 写入文件头注释
    if (header_comment) {
        fprintf(file, "%s\n", header_comment);
    } else {
        fprintf(file, "# 配置文件\n");
        fprintf(file, "# 格式：key=value\n");
        fprintf(file, "# 以#开头的行为注释行\n\n");
    }
    
    // 写入配置项
    for (size_t i = 0; i < item_count; i++) {
        fprintf(file, "%s=%s\n", items[i].key, items[i].value);
    }
    
    fclose(file);
    
    LOG_INFO(LOG_MODULE_NAME, "cfg配置文件保存成功: %s, 保存了%zu个配置项", cfg_file, item_count);
    return CFG_SUCCESS;
}

/**
 * @brief 解析cfg配置行
 * @details 解析key=value格式的配置行
 * 
 * @param line 配置行
 * @param key 输出键名
 * @param value 输出值
 * @return 解析结果
 */
cfg_result_t cfg_utils_parse_line(const char *line, char *key, char *value) {
    LOG_DEBUG(LOG_MODULE_NAME, "解析cfg配置行: %s", line);
    
    if (!line || !key || !value) {
        LOG_ERROR(LOG_MODULE_NAME, "参数为空");
        snprintf(g_error_message, sizeof(g_error_message), "参数为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    // 使用sscanf解析key=value格式
    if (sscanf(line, "%127[^=]=%255s", key, value) != 2) {
        LOG_ERROR(LOG_MODULE_NAME, "解析失败，格式应为key=value: %s", line);
        snprintf(g_error_message, sizeof(g_error_message), "解析失败，格式应为key=value: %s", line);
        return CFG_ERROR_PARSE_FAILED;
    }
    
    // 去除key和value的空格
    cfg_utils_trim_string(key);
    cfg_utils_trim_string(value);
    
    LOG_DEBUG(LOG_MODULE_NAME, "解析成功: %s = %s", key, value);
    return CFG_SUCCESS;
}

/**
 * @brief 检查是否为注释行
 * @details 检查行是否以#开头（注释行）
 * 
 * @param line 行内容
 * @return true: 是注释行, false: 不是注释行
 */
bool cfg_utils_is_comment_line(const char *line) {
    if (!line) {
        return false;
    }
    
    // 跳过前导空格
    while (*line == ' ' || *line == '\t') {
        line++;
    }
    
    bool is_comment = (*line == '#');
    LOG_DEBUG(LOG_MODULE_NAME, "检查注释行: %s -> %s", line, is_comment ? "是" : "否");
    return is_comment;
}

/**
 * @brief 去除字符串首尾空格
 * @details 修改原字符串，去除首尾空格
 * 
 * @param str 字符串指针
 */
void cfg_utils_trim_string(char *str) {
    if (!str) {
        return;
    }
    
    char *start = str;
    char *end = str + strlen(str) - 1;
    
    // 去除尾部空格
    while (end > start && (*end == ' ' || *end == '\t')) {
        end--;
    }
    *(end + 1) = '\0';
    
    // 去除首部空格
    while (*start == ' ' || *start == '\t') {
        start++;
    }
    
    // 移动字符串到开头
    if (start != str) {
        memmove(str, start, strlen(start) + 1);
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "去除空格: '%s'", str);
}

/**
 * @brief 获取cfg错误信息
 * @details 获取最后一次cfg操作的错误信息
 * 
 * @return 错误信息字符串
 */
const char* cfg_utils_get_error(void) {
    LOG_DEBUG(LOG_MODULE_NAME, "获取cfg错误信息: %s", g_error_message);
    return g_error_message;
}

/* ==================== 104协议应用配置管理 ==================== */

// 全局配置
static app_config_t g_app_config;
static bool g_config_initialized = false;

// 默认配置值
#define DEFAULT_SERVER_IP "127.0.0.1"
#define DEFAULT_SERVER_PORT 2404
#define DEFAULT_TIMEOUT_MS 5000
#define DEFAULT_BUFFER_SIZE 4096
#define DEFAULT_TESTFR_INTERVAL 20
#define DEFAULT_LOG_LEVEL 2
#define DEFAULT_MAX_FILE_SIZE (10 * 1024 * 1024) // 10MB
#define DEFAULT_MAX_FILE_COUNT 5

/* ==================== 内部函数声明 ==================== */

static void set_default_config(void);
static bool validate_network_config(const app_network_config_t *config);
static bool validate_log_config(const log_config_t *config);
static cfg_result_t app_cfg_item_callback(const char *key, const char *value, void *user_data);

/**
 * @brief 初始化应用配置
 * @details 初始化应用配置模块，设置默认配置值
 * 
 * @return 初始化结果
 */
int app_config_init(void) {
    LOG_DEBUG(LOG_MODULE_NAME, "初始化应用配置模块");
    
    if (g_config_initialized) {
        LOG_WARN(LOG_MODULE_NAME, "应用配置模块已经初始化");
        return 0;
    }
    
    // 设置默认配置
    set_default_config();
    g_config_initialized = true;
    
    LOG_INFO(LOG_MODULE_NAME, "应用配置模块初始化完成");
    return 0;
}

/**
 * @brief 加载应用配置文件
 * @details 从cfg文件加载104协议应用配置
 * 
 * @param config_file 配置文件路径
 * @return 加载结果
 */
cfg_result_t app_config_load(const char *config_file) {
    LOG_DEBUG(LOG_MODULE_NAME, "加载应用配置文件: %s", config_file);
    
    if (!config_file) {
        LOG_ERROR(LOG_MODULE_NAME, "配置文件路径为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    if (!g_config_initialized) {
        LOG_ERROR(LOG_MODULE_NAME, "应用配置模块未初始化");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    // 使用cfg工具加载文件
    cfg_result_t result = cfg_utils_load_file(config_file, app_cfg_item_callback, &g_app_config);
    if (result != CFG_SUCCESS) {
        LOG_ERROR(LOG_MODULE_NAME, "应用配置文件加载失败: %s", cfg_utils_get_error());
        return result;
    }
    
    // 验证配置
    if (app_config_validate(&g_app_config) != CFG_SUCCESS) {
        LOG_ERROR(LOG_MODULE_NAME, "应用配置验证失败");
        return CFG_ERROR_PARSE_FAILED;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "应用配置文件加载成功: %s", config_file);
    return CFG_SUCCESS;
}

/**
 * @brief 保存应用配置文件
 * @details 将当前应用配置保存为cfg文件
 * 
 * @param config_file 配置文件路径
 * @return 保存结果
 */
cfg_result_t app_config_save(const char *config_file) {
    LOG_DEBUG(LOG_MODULE_NAME, "保存应用配置文件: %s", config_file);
    
    if (!config_file) {
        LOG_ERROR(LOG_MODULE_NAME, "配置文件路径为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    if (!g_config_initialized) {
        LOG_ERROR(LOG_MODULE_NAME, "应用配置模块未初始化");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    // 准备配置项数组
    cfg_item_t items[18];
    
    // 应用程序配置
    strncpy(items[0].key, "app_name", sizeof(items[0].key) - 1);
    items[0].key[sizeof(items[0].key) - 1] = '\0';
    strncpy(items[0].value, g_app_config.app_name, sizeof(items[0].value) - 1);
    items[0].value[sizeof(items[0].value) - 1] = '\0';
    
    strncpy(items[1].key, "version", sizeof(items[1].key) - 1);
    items[1].key[sizeof(items[1].key) - 1] = '\0';
    strncpy(items[1].value, g_app_config.version, sizeof(items[1].value) - 1);
    items[1].value[sizeof(items[1].value) - 1] = '\0';
    
    strncpy(items[2].key, "debug_mode", sizeof(items[2].key) - 1);
    items[2].key[sizeof(items[2].key) - 1] = '\0';
    strncpy(items[2].value, g_app_config.debug_mode ? "true" : "false", sizeof(items[2].value) - 1);
    items[2].value[sizeof(items[2].value) - 1] = '\0';
    
    
    // 网络配置
    strncpy(items[3].key, "server_ip", sizeof(items[3].key) - 1);
    items[3].key[sizeof(items[3].key) - 1] = '\0';
    strncpy(items[3].value, g_app_config.protocol_104.server_ip, sizeof(items[3].value) - 1);
    items[3].value[sizeof(items[3].value) - 1] = '\0';
    
    strncpy(items[4].key, "server_port", sizeof(items[4].key) - 1);
    items[4].key[sizeof(items[4].key) - 1] = '\0';
    
    strncpy(items[5].key, "timeout_ms", sizeof(items[5].key) - 1);
    items[5].key[sizeof(items[5].key) - 1] = '\0';
    
    strncpy(items[6].key, "buffer_size", sizeof(items[6].key) - 1);
    items[6].key[sizeof(items[6].key) - 1] = '\0';
    
    strncpy(items[7].key, "auto_reconnect", sizeof(items[7].key) - 1);
    items[7].key[sizeof(items[7].key) - 1] = '\0';
    strncpy(items[7].value, g_app_config.network.auto_reconnect ? "true" : "false", sizeof(items[7].value) - 1);
    items[7].value[sizeof(items[7].value) - 1] = '\0';
    
    strncpy(items[8].key, "reconnect_interval", sizeof(items[8].key) - 1);
    items[8].key[sizeof(items[8].key) - 1] = '\0';
    
    strncpy(items[9].key, "max_reconnect_count", sizeof(items[9].key) - 1);
    items[9].key[sizeof(items[9].key) - 1] = '\0';
    
    // 协议配置使用协议标准规定的宏定义，无需配置
    
    // 日志配置
    strncpy(items[10].key, "log_path", sizeof(items[10].key) - 1);
    items[10].key[sizeof(items[10].key) - 1] = '\0';
    strncpy(items[10].value, g_app_config.log.log_path, sizeof(items[10].value) - 1);
    items[10].value[sizeof(items[10].value) - 1] = '\0';
    
    strncpy(items[11].key, "log_level", sizeof(items[11].key) - 1);
    items[11].key[sizeof(items[11].key) - 1] = '\0';
    
    strncpy(items[12].key, "max_file_size", sizeof(items[12].key) - 1);
    items[12].key[sizeof(items[12].key) - 1] = '\0';
    
    // 设置数值类型的配置项
    snprintf(items[4].value, sizeof(items[4].value), "%u", g_app_config.protocol_104.server_port);
    snprintf(items[5].value, sizeof(items[5].value), "%u", g_app_config.network.timeout_ms);
    snprintf(items[6].value, sizeof(items[6].value), "%u", g_app_config.network.buffer_size);
    snprintf(items[8].value, sizeof(items[8].value), "%u", g_app_config.network.reconnect_interval);
    snprintf(items[9].value, sizeof(items[9].value), "%u", g_app_config.network.max_reconnect_count);
    snprintf(items[11].value, sizeof(items[11].value), "%u", g_app_config.log.log_level);
    snprintf(items[12].value, sizeof(items[12].value), "%u", g_app_config.log.max_file_size);
    
    // 准备文件头注释
    const char *header_comment = 
        "# 104协议应用程序配置文件\n"
        "# 配置文件格式：key=value\n"
        "# 以#开头的行为注释行\n"
        "# \n"
        "# 作者: zyb\n"
        "# 日期: 2025-01-13\n"
        "# 版本: 1.0\n\n"
        "# ==================== 应用程序配置 ====================\n"
        "# ==================== 网络配置 ====================\n"
        "# ==================== 协议配置 ====================\n"
        "# ==================== 日志配置 ====================";
    
    // 使用cfg工具保存文件
    cfg_result_t result = cfg_utils_save_file(config_file, items, sizeof(items) / sizeof(items[0]), header_comment);
    if (result != CFG_SUCCESS) {
        LOG_ERROR(LOG_MODULE_NAME, "应用配置文件保存失败: %s", cfg_utils_get_error());
        return result;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "应用配置文件保存成功: %s", config_file);
    return CFG_SUCCESS;
}

/**
 * @brief 获取应用程序配置
 * @details 获取当前的应用程序配置
 * 
 * @param config 配置结构指针
 * @return 获取结果
 */
cfg_result_t app_config_get(app_config_t *config) {
    LOG_DEBUG(LOG_MODULE_NAME, "获取应用程序配置");
    
    if (!config) {
        LOG_ERROR(LOG_MODULE_NAME, "配置结构指针为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    if (!g_config_initialized) {
        LOG_ERROR(LOG_MODULE_NAME, "应用配置模块未初始化");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    *config = g_app_config;
    LOG_DEBUG(LOG_MODULE_NAME, "应用程序配置获取成功");
    return CFG_SUCCESS;
}

/**
 * @brief 设置应用程序配置
 * @details 设置应用程序配置参数
 * 
 * @param config 配置结构指针
 * @return 设置结果
 */
cfg_result_t app_config_set(const app_config_t *config) {
    LOG_DEBUG(LOG_MODULE_NAME, "设置应用程序配置");
    
    if (!config) {
        LOG_ERROR(LOG_MODULE_NAME, "配置结构指针为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    if (!g_config_initialized) {
        LOG_ERROR(LOG_MODULE_NAME, "应用配置模块未初始化");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    // 验证配置
    if (app_config_validate(config) != CFG_SUCCESS) {
        LOG_ERROR(LOG_MODULE_NAME, "配置验证失败");
        return CFG_ERROR_PARSE_FAILED;
    }
    
    g_app_config = *config;
    LOG_DEBUG(LOG_MODULE_NAME, "应用程序配置设置成功");
    return CFG_SUCCESS;
}

/**
 * @brief 验证配置参数
 * @details 验证配置参数的有效性
 * 
 * @param config 配置结构指针
 * @return 验证结果
 */
cfg_result_t app_config_validate(const app_config_t *config) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证配置参数");
    
    if (!config) {
        LOG_ERROR(LOG_MODULE_NAME, "配置结构指针为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    // 验证网络配置
    if (!validate_network_config(&config->network)) {
        LOG_ERROR(LOG_MODULE_NAME, "网络配置验证失败");
        return CFG_ERROR_PARSE_FAILED;
    }
    
    // 协议配置使用协议标准规定的宏定义，无需验证
    
    // 验证日志配置
    if (!validate_log_config(&config->log)) {
        LOG_ERROR(LOG_MODULE_NAME, "日志配置验证失败");
        return CFG_ERROR_PARSE_FAILED;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "配置参数验证成功");
    return CFG_SUCCESS;
}

/**
 * @brief 重置为默认配置
 * @details 将所有配置参数重置为默认值
 * 
 * @return 重置结果
 */
cfg_result_t app_config_reset_defaults(void) {
    LOG_DEBUG(LOG_MODULE_NAME, "重置为默认配置");
    
    if (!g_config_initialized) {
        LOG_ERROR(LOG_MODULE_NAME, "应用配置模块未初始化");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    set_default_config();
    LOG_DEBUG(LOG_MODULE_NAME, "默认配置重置成功");
    return CFG_SUCCESS;
}

/**
 * @brief 获取网络配置
 * @details 获取网络配置参数
 * 
 * @param network_config 网络配置结构指针
 * @return 获取结果
 */
cfg_result_t app_config_get_network(app_network_config_t *network_config) {
    LOG_DEBUG(LOG_MODULE_NAME, "获取网络配置");
    
    if (!network_config) {
        LOG_ERROR(LOG_MODULE_NAME, "网络配置结构指针为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    if (!g_config_initialized) {
        LOG_ERROR(LOG_MODULE_NAME, "应用配置模块未初始化");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    *network_config = g_app_config.network;
    LOG_DEBUG(LOG_MODULE_NAME, "网络配置获取成功");
    return CFG_SUCCESS;
}

/**
 * @brief 设置网络配置
 * @details 设置网络配置参数
 * 
 * @param network_config 网络配置结构指针
 * @return 设置结果
 */
cfg_result_t app_config_set_network(const app_network_config_t *network_config) {
    LOG_DEBUG(LOG_MODULE_NAME, "设置网络配置");
    
    if (!network_config) {
        LOG_ERROR(LOG_MODULE_NAME, "网络配置结构指针为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    if (!g_config_initialized) {
        LOG_ERROR(LOG_MODULE_NAME, "应用配置模块未初始化");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    // 验证网络配置
    if (!validate_network_config(network_config)) {
        LOG_ERROR(LOG_MODULE_NAME, "网络配置验证失败");
        return CFG_ERROR_PARSE_FAILED;
    }
    
    g_app_config.network = *network_config;
    LOG_DEBUG(LOG_MODULE_NAME, "网络配置设置成功");
    return CFG_SUCCESS;
}


/**
 * @brief 获取日志配置
 * @details 获取日志配置参数
 * 
 * @param log_config 日志配置结构指针
 * @return 获取结果
 */
cfg_result_t app_config_get_log(log_config_t *log_config) {
    LOG_DEBUG(LOG_MODULE_NAME, "获取日志配置");
    
    if (!log_config) {
        LOG_ERROR(LOG_MODULE_NAME, "日志配置结构指针为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    if (!g_config_initialized) {
        LOG_ERROR(LOG_MODULE_NAME, "应用配置模块未初始化");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    *log_config = g_app_config.log;
    LOG_DEBUG(LOG_MODULE_NAME, "日志配置获取成功");
    return CFG_SUCCESS;
}

/**
 * @brief 设置日志配置
 * @details 设置日志配置参数
 * 
 * @param log_config 日志配置结构指针
 * @return 设置结果
 */
cfg_result_t app_config_set_log(const log_config_t *log_config) {
    LOG_DEBUG(LOG_MODULE_NAME, "设置日志配置");
    
    if (!log_config) {
        LOG_ERROR(LOG_MODULE_NAME, "日志配置结构指针为空");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    if (!g_config_initialized) {
        LOG_ERROR(LOG_MODULE_NAME, "应用配置模块未初始化");
        return CFG_ERROR_INVALID_PARAM;
    }
    
    // 验证日志配置
    if (!validate_log_config(log_config)) {
        LOG_ERROR(LOG_MODULE_NAME, "日志配置验证失败");
        return CFG_ERROR_PARSE_FAILED;
    }
    
    g_app_config.log = *log_config;
    LOG_DEBUG(LOG_MODULE_NAME, "日志配置设置成功");
    return CFG_SUCCESS;
}

/**
 * @brief 销毁应用配置
 * @details 清理应用配置资源
 */
void app_config_destroy(void) {
    LOG_DEBUG(LOG_MODULE_NAME, "销毁应用配置模块");
    
    g_config_initialized = false;
    memset(&g_app_config, 0, sizeof(g_app_config));
    
    LOG_INFO(LOG_MODULE_NAME, "应用配置模块销毁完成");
}

/* ==================== 内部函数实现 ==================== */

/**
 * @brief 设置默认配置
 * @details 设置所有配置参数的默认值
 */
static void set_default_config(void) {
    LOG_DEBUG(LOG_MODULE_NAME, "设置默认配置");
    
    // 应用程序配置
    strncpy(g_app_config.app_name, "104_Protocol_App", sizeof(g_app_config.app_name) - 1);
    g_app_config.app_name[sizeof(g_app_config.app_name) - 1] = '\0';
    strncpy(g_app_config.version, "1.0.0", sizeof(g_app_config.version) - 1);
    g_app_config.version[sizeof(g_app_config.version) - 1] = '\0';
    g_app_config.debug_mode = true;
    
    // 104协议配置
    strncpy(g_app_config.protocol_104.server_ip, DEFAULT_SERVER_IP, sizeof(g_app_config.protocol_104.server_ip) - 1);
    g_app_config.protocol_104.server_ip[sizeof(g_app_config.protocol_104.server_ip) - 1] = '\0';
    g_app_config.protocol_104.server_port = DEFAULT_SERVER_PORT;
    
    // 网络配置
    g_app_config.network.timeout_ms = DEFAULT_TIMEOUT_MS;
    g_app_config.network.buffer_size = DEFAULT_BUFFER_SIZE;
    g_app_config.network.auto_reconnect = true;
    g_app_config.network.reconnect_interval = 10;
    g_app_config.network.max_reconnect_count = 5;
    g_app_config.network.heartbeat_interval = 10;
    
    // 协议配置使用协议标准规定的宏定义，无需设置
    
    // 日志配置
    strncpy(g_app_config.log.log_path, "./output/logs", sizeof(g_app_config.log.log_path) - 1);
    g_app_config.log.log_path[sizeof(g_app_config.log.log_path) - 1] = '\0';
    g_app_config.log.log_level = DEFAULT_LOG_LEVEL;
    g_app_config.log.max_file_size = 5 * 1024 * 1024;  // 5MB
    
    LOG_DEBUG(LOG_MODULE_NAME, "默认配置设置完成");
}

/**
 * @brief 验证网络配置
 * @details 验证网络配置参数的有效性
 * 
 * @param config 网络配置结构指针
 * @return true: 有效, false: 无效
 */
static bool validate_network_config(const app_network_config_t *config) {
    if (!config) {
        return false;
    }
    
    // 网络配置验证（server_ip和server_port现在在protocol_104中）
    // 这里只验证网络相关的配置
    
    // 验证超时时间
    if (config->timeout_ms == 0 || config->timeout_ms > 60000) {
        return false;
    }
    
    // 验证缓冲区大小
    if (config->buffer_size == 0 || config->buffer_size > 1024 * 1024) {
        return false;
    }
    
    // 验证重连间隔
    if (config->reconnect_interval == 0 || config->reconnect_interval > 3600) {
        return false;
    }
    
    // 验证最大重连次数
    if (config->max_reconnect_count > 100) {
        return false;
    }
    
    return true;
}


/**
 * @brief 验证日志配置
 * @details 验证日志配置参数的有效性
 * 
 * @param config 日志配置结构指针
 * @return true: 有效, false: 无效
 */
static bool validate_log_config(const log_config_t *config) {
    if (!config) {
        return false;
    }
    
    // 验证日志文件路径
    if (strlen(config->log_path) == 0) {
        return false;
    }
    
    // 验证日志级别
    if (config->log_level > 5) {
        return false;
    }
    
    // 验证文件大小
    if (config->max_file_size == 0 || config->max_file_size > 100 * 1024 * 1024) {
        return false;
    }
    
    return true;
}

/**
 * @brief 应用配置项回调函数
 * @details 处理cfg文件解析到的每个配置项
 * 
 * @param key 配置项键名
 * @param value 配置项值
 * @param user_data 用户数据指针（app_config_t*）
 * @return 处理结果
 */
static cfg_result_t app_cfg_item_callback(const char *key, const char *value, void *user_data) {
    if (!key || !value || !user_data) {
        return CFG_ERROR_INVALID_PARAM;
    }
    
    app_config_t *config = (app_config_t*)user_data;
    
    LOG_DEBUG(LOG_MODULE_NAME, "处理应用配置项: %s = %s", key, value);
    
    // 根据key设置对应的配置值
    if (strcmp(key, "app_name") == 0) {
        strncpy(config->app_name, value, sizeof(config->app_name) - 1);
        config->app_name[sizeof(config->app_name) - 1] = '\0';
    } else if (strcmp(key, "version") == 0) {
        strncpy(config->version, value, sizeof(config->version) - 1);
        config->version[sizeof(config->version) - 1] = '\0';
    } else if (strcmp(key, "debug_mode") == 0) {
        config->debug_mode = (strcmp(value, "true") == 0);
    } else if (strcmp(key, "server_ip") == 0) {
        strncpy(config->protocol_104.server_ip, value, sizeof(config->protocol_104.server_ip) - 1);
        config->protocol_104.server_ip[sizeof(config->protocol_104.server_ip) - 1] = '\0';
    } else if (strcmp(key, "server_port") == 0) {
        config->protocol_104.server_port = (uint16_t)atoi(value);
    } else if (strcmp(key, "timeout_ms") == 0) {
        config->network.timeout_ms = (uint32_t)atoi(value);
    } else if (strcmp(key, "buffer_size") == 0) {
        config->network.buffer_size = (uint32_t)atoi(value);
    } else if (strcmp(key, "auto_reconnect") == 0) {
        config->network.auto_reconnect = (strcmp(value, "true") == 0);
    } else if (strcmp(key, "reconnect_interval") == 0) {
        config->network.reconnect_interval = (uint32_t)atoi(value);
    } else if (strcmp(key, "max_reconnect_count") == 0) {
        config->network.max_reconnect_count = (uint32_t)atoi(value);
    } else if (strcmp(key, "heartbeat_interval") == 0) {
        config->network.heartbeat_interval = (uint32_t)atoi(value);
    // 协议配置使用协议标准规定的宏定义，无需解析
    } else if (strcmp(key, "log_path") == 0) {
        strncpy(config->log.log_path, value, sizeof(config->log.log_path) - 1);
        config->log.log_path[sizeof(config->log.log_path) - 1] = '\0';
    } else if (strcmp(key, "log_level") == 0) {
        config->log.log_level = (uint32_t)atoi(value);
    } else if (strcmp(key, "max_file_size") == 0) {
        config->log.max_file_size = (uint32_t)atoi(value);
    } else {
        LOG_WARN(LOG_MODULE_NAME, "未知的应用配置项: %s", key);
        return CFG_ERROR_PARSE_FAILED;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "应用配置项处理成功: %s = %s", key, value);
    return CFG_SUCCESS;
}

/**
 * @brief 获取104协议配置
 * @details 获取当前加载的104协议配置参数
 * 
 * @param protocol_104_config 104协议配置结构指针
 * @return 获取结果
 */
cfg_result_t app_config_get_protocol_104(app_protocol_104_config_t *protocol_104_config) {
    if (!protocol_104_config) {
        return CFG_ERROR_INVALID_PARAM;
    }
    
    *protocol_104_config = g_app_config.protocol_104;
    return CFG_SUCCESS;
}
